/**
 * 会话管理器
 * 
 * 用途：管理脑波监测会话的生命周期，包括会话创建、状态管理和数据清理
 * 方法：协调SessionApiClient和DataCacheManager，提供统一的会话管理接口
 * 原理：实现会话状态机，在新会话开始时清理旧数据，管理会话ID和状态
 */
package com.example.brain_wave.bluetooth.session

import com.example.brain_wave.bluetooth.api.SessionApiClient
import com.example.brain_wave.bluetooth.api.SessionResponse
import com.example.brain_wave.bluetooth.cache.DataCacheManager
import android.content.Context
import android.util.Log
import kotlinx.coroutines.*

/**
 * 会话状态枚举
 */
enum class SessionState {
    IDLE,           // 空闲状态，无活动会话
    CONNECTING,     // 正在创建会话
    ACTIVE,         // 会话活跃中
    DISCONNECTED    // 会话已断开
}

class SessionManager(private val context: Context) {
    
    private val sessionApiClient = SessionApiClient(context)
    private var dataCacheManager: DataCacheManager? = null
    
    // 会话状态
    private var currentState = SessionState.IDLE
    private var currentSession: SessionResponse? = null
    
    // 回调函数
    private var onSessionStateChanged: ((SessionState, SessionResponse?) -> Unit)? = null
    private var onError: ((String) -> Unit)? = null
    
    /**
     * 配置会话管理器
     */
    fun configure(
        sessionApiBaseUrl: String,
        dataCacheManager: DataCacheManager
    ) {
        println("SessionManager: configure 被调用 - sessionApiBaseUrl=$sessionApiBaseUrl")
        
        this.dataCacheManager = dataCacheManager
        sessionApiClient.setBaseUrl(sessionApiBaseUrl)
        
        println("SessionManager: 设置会话API回调")
        // 设置会话API回调
        sessionApiClient.setOnSessionCreated { sessionResponse ->
            println("SessionManager: 收到会话创建成功回调")
            handleSessionCreated(sessionResponse)
        }
        
        sessionApiClient.setOnError { error ->
            println("SessionManager: 收到会话创建错误回调: $error")
            handleSessionError(error)
        }
        
        println("SessionManager: configure 完成")
    }
    
    /**
     * 设置会话状态变化回调
     */
    fun setOnSessionStateChanged(callback: (SessionState, SessionResponse?) -> Unit) {
        onSessionStateChanged = callback
    }
    
    /**
     * 设置错误回调
     */
    fun setOnError(callback: (String) -> Unit) {
        onError = callback
    }
    
    /**
     * 开始新会话（连接设备）- 同步版本
     */
    fun startNewSession(roomId: String, userId: String? = null) {
        try {
            println("SessionManager: 开始创建新会话，房间ID: $roomId, 用户ID: $userId")
            println("SessionManager: 当前状态: $currentState")
            
            if (currentState == SessionState.CONNECTING) {
                println("正在创建会话中，忽略重复请求")
                onError?.invoke("正在创建会话中，请稍候...")
                return
            }
            
            // 更新状态为连接中
            println("SessionManager: 更新状态为 CONNECTING")
            updateState(SessionState.CONNECTING)
            
            // 清理上一个会话的数据
            clearPreviousSessionData()
            
            // 使用协程进行同步调用
            CoroutineScope(Dispatchers.IO).launch {
                try {
                    println("SessionManager: 调用同步会话创建")
                    val result = sessionApiClient.createSessionSync(roomId, userId)
                    
                    // 在主线程更新UI状态
                    CoroutineScope(Dispatchers.Main).launch {
                        if (result.isSuccess) {
                            val sessionResponse = result.getOrNull()!!
                            println("SessionManager: 同步会话创建成功")
                            handleSessionCreated(sessionResponse)
                        } else {
                            val error = result.exceptionOrNull()?.message ?: "未知错误"
                            println("SessionManager: 同步会话创建失败: $error")
                            handleSessionError(error)
                        }
                    }
                } catch (e: Exception) {
                    println("SessionManager: 同步会话创建异常: ${e.message}")
                    CoroutineScope(Dispatchers.Main).launch {
                        handleSessionError("创建会话异常: ${e.message}")
                    }
                }
            }
            
        } catch (e: Exception) {
            println("SessionManager: 创建会话时发生异常: ${e.message}")
            e.printStackTrace()
            updateState(SessionState.IDLE)
            onError?.invoke("创建会话失败: ${e.message}")
        }
    }
    
    /**
     * 断开当前会话
     */
    fun disconnectSession() {
        try {
            println("SessionManager: 开始断开会话，当前状态: $currentState")
            
            if (currentState == SessionState.ACTIVE) {
                updateState(SessionState.DISCONNECTED)
                println("SessionManager: 会话已断开")
                // 注意：断开会话时不清理数据，保留显示
            } else {
                println("SessionManager: 当前没有活跃会话，状态: $currentState")
            }
            
        } catch (e: Exception) {
            println("SessionManager: 断开会话时发生异常: ${e.message}")
            e.printStackTrace()
            onError?.invoke("断开会话失败: ${e.message}")
        }
    }
    
    /**
     * 获取当前会话状态
     */
    fun getCurrentState(): SessionState = currentState
    
    /**
     * 获取当前会话信息
     */
    fun getCurrentSession(): SessionResponse? = currentSession
    
    /**
     * 获取当前会话ID
     */
    fun getCurrentSessionId(): String? = currentSession?.id
    
    /**
     * 检查是否有活跃会话
     */
    fun hasActiveSession(): Boolean = currentState == SessionState.ACTIVE
    
    /**
     * 处理会话创建成功
     */
    private fun handleSessionCreated(sessionResponse: SessionResponse) {
        println("SessionManager: 会话创建成功，会话ID: ${sessionResponse.id}")
        println("SessionManager: 会话信息 - 房间ID: ${sessionResponse.room_id}, 用户ID: ${sessionResponse.user_id}")
        currentSession = sessionResponse
        println("SessionManager: 更新状态为 ACTIVE")
        updateState(SessionState.ACTIVE)
        println("SessionManager: 状态更新完成，当前状态: $currentState")
    }
    
    /**
     * 处理会话创建错误
     */
    private fun handleSessionError(error: String) {
        println("SessionManager: 会话创建失败 - $error")
        Log.e("SessionManager", "❌ 会话创建失败: $error")
        updateState(SessionState.IDLE)
        onError?.invoke(error)
    }
    
    /**
     * 更新会话状态
     */
    private fun updateState(newState: SessionState) {
        val oldState = currentState
        currentState = newState
        
        println("SessionManager: 状态变化 - 从 $oldState 到 $newState")
        
        // 如果状态发生变化，通知回调
        if (oldState != newState) {
            println("SessionManager: 调用状态变化回调，会话信息: ${currentSession?.id}")
            onSessionStateChanged?.invoke(newState, currentSession)
            println("SessionManager: 状态变化回调调用完成")
        } else {
            println("SessionManager: 状态未变化，不调用回调")
        }
    }
    
    /**
     * 清理上一个会话的数据
     */
    private fun clearPreviousSessionData() {
        dataCacheManager?.clearCache()
    }
    
    /**
     * 测试会话API连接
     */
    suspend fun testSessionApiConnection(): Boolean {
        return sessionApiClient.testConnection()
    }
    
    /**
     * 重置会话管理器
     */
    fun reset() {
        currentSession = null
        updateState(SessionState.IDLE)
    }
}